home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 1 / QRZ Ham Radio Callsign Database - December 1993.iso / ucsd / packet / tcpip / amiga / asrc29k.lha / rspfhdr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-08  |  4.7 KB  |  172 lines
  1. #include "global.h"
  2. #include "mbuf.h"
  3. #include "internet.h"
  4. #include "timer.h"
  5. #include "rspf.h"
  6. #include "ip.h"
  7.  
  8. /* Convert RRH header in internal format to an mbuf in external format */
  9. struct mbuf *
  10. htonrrh(rrh,data,ph)
  11. struct rrh *rrh;
  12. struct mbuf *data;
  13. struct pseudo_header *ph;
  14. {
  15.     struct mbuf *bp;
  16.     register char *cp, *ck;
  17.     int16 checksum;
  18.  
  19.     /* Allocate RRH header and fill it in */
  20.     bp = pushdown(data,RRHLEN);    /* pushdown never fails */
  21.  
  22.     cp = bp->data;
  23.     *cp++ = rrh->version;        /* Version number */
  24.     *cp++ = RSPF_RRH;        /* Type number */
  25.     ck = cp;
  26.     cp = put16(cp,0);        /* Clear checksum */
  27.     cp = put32(cp,rrh->addr);    /* Source address */
  28.     cp = put16(cp,rrh->seq);    /* Last packet sent sequence number */
  29.     *cp = rrh->flags;        /* Flags */
  30.  
  31.     /* All zeros and all ones is equivalent in one's complement arithmetic;
  32.      * the spec requires us to change zeros into ones to distinguish an
  33.       * all-zero checksum from no checksum at all
  34.      */
  35.     if((checksum = cksum(ph,bp,ph->length)) == 0)
  36.         checksum = 0xffffffff;
  37.     put16(ck,checksum);
  38.     return bp;
  39. }
  40.  
  41. /* Convert RSPF packet header in internal format to an mbuf in external
  42.  * format, without calculating the checksum.
  43.  */
  44. struct mbuf *
  45. htonrspf(pkth,data)
  46. struct rspfpacketh *pkth;
  47. struct mbuf *data;
  48. {
  49.     struct mbuf *bp;
  50.     register unsigned char *cp;
  51.  
  52.     /* Allocate packet header and fill it in */
  53.     bp = pushdown(data,RSPFPKTLEN);    /* pushdown never fails */
  54.  
  55.     cp = (unsigned char *) bp->data;
  56.     *cp++ = (char) pkth->version;    /* Version number */
  57.     *cp++ = (char) pkth->type;    /* Type number */
  58.     *cp++ = pkth->fragn;        /* The fragment number */
  59.     *cp++ = pkth->fragtot;        /* The total number of fragments */
  60.     cp = (unsigned char *) put16((char *)cp,pkth->csum); /* The checksum */
  61.     *cp++ = pkth->sync;        /* The sync octet */
  62.     *cp++ = pkth->nodes;        /* The number of nodes */
  63.     put16((char *)cp,pkth->envid);  /* The envelope-ID */
  64.     return bp;
  65. }
  66.  
  67. /* Convert RSPF header in mbuf to internal structure */
  68. int
  69. ntohrspf(rspf,bpp)
  70. union rspf *rspf;
  71. struct mbuf **bpp;
  72. {
  73.     if(len_p(*bpp) < RSPFPKTLEN) /* Packet too short */
  74.         return -1;
  75.     if((rspf->hdr.version = pullchar(bpp)) != RSPF_VERSION) {
  76.         ++Rspf_stat.badvers;
  77.         return -1;             /* Wrong version */
  78.         }
  79.  
  80.     switch (rspf->hdr.type = pullchar(bpp)){
  81.     case RSPF_RRH:
  82.         if(len_p(*bpp) < RRHLEN - 2)    /* Packet too small */
  83.         return -1;
  84.         rspf->rrh.csum = (int16) pull16(bpp);
  85.         rspf->rrh.addr = pull32(bpp);
  86.         rspf->rrh.seq = (int16) pull16(bpp);
  87.         rspf->rrh.flags = pullchar(bpp);
  88.         break;
  89.     case RSPF_FULLPKT:
  90.         rspf->pkthdr.fragn = pullchar(bpp);
  91.         rspf->pkthdr.fragtot = pullchar(bpp);
  92.         rspf->pkthdr.csum = (int16) pull16(bpp);
  93.         rspf->pkthdr.sync = pullchar(bpp);
  94.         rspf->pkthdr.nodes = pullchar(bpp);
  95.         rspf->pkthdr.envid = (int16) pull16(bpp);
  96.         break;
  97.     default:
  98.         return -1;
  99.     }
  100.     return 0;
  101. }
  102.  
  103. /* Convert RSPF node header in internal format to an mbuf in external format */
  104. struct mbuf *
  105. htonrspfnode(nodeh,data)
  106. struct rspfnodeh *nodeh;
  107. struct mbuf *data;
  108. {
  109.     struct mbuf *bp;
  110.     register char *cp;
  111.  
  112.     /* Allocate node header and fill it in */
  113.     bp = pushdown(data,RSPFNODELEN);    /* pushdown never fails */
  114.  
  115.     cp = bp->data;
  116.     cp = put32(cp,nodeh->addr);        /* Reporting router address */
  117.     cp = put16(cp,(int16)nodeh->seq);    /* Sequence number */
  118.     *cp++ = nodeh->subseq;        /* Sub-sequence number */
  119.     *cp++ = nodeh->links;        /* Number of links */
  120.     return bp;
  121. }
  122.  
  123. /* Convert RSPF node header in mbuf to internal structure */
  124. int
  125. ntohrspfnode(nodeh,bpp)
  126. struct rspfnodeh *nodeh;
  127. struct mbuf **bpp;
  128. {
  129.     if(len_p(*bpp) < RSPFNODELEN) /* Packet too short */
  130.     return -1;
  131.     nodeh->addr = pull32(bpp);
  132.     nodeh->seq = (short) pull16(bpp);
  133.     nodeh->subseq = (unsigned char) pullchar(bpp);
  134.     nodeh->links = (unsigned char) pullchar(bpp);
  135.     return 0;
  136. }
  137.  
  138. /* Convert RSPF link header in internal format to an mbuf in external format */
  139. struct mbuf *
  140. htonrspflink(linkh,data)
  141. struct rspflinkh *linkh;
  142. struct mbuf *data;
  143. {
  144.     struct mbuf *bp;
  145.     register unsigned char *cp;
  146.  
  147.     /* Allocate link header and fill it in */
  148.     bp = pushdown(data,RSPFLINKLEN);    /* pushdown never fails */
  149.  
  150.     cp = (unsigned char *) bp->data;
  151.     *cp++ = linkh->horizon;        /* Horizon */
  152.     *cp++ = linkh->erp;            /* ERP factor */
  153.     *cp++ = linkh->cost;        /* Link cost */
  154.     *cp++ = linkh->adjn;        /* Number of adjacencies */
  155.     return bp;
  156. }
  157.  
  158. /* Convert RSPF link header in mbuf to internal structure */
  159. int
  160. ntohrspflink(linkh,bpp)
  161. struct rspflinkh *linkh;
  162. struct mbuf **bpp;
  163. {
  164.     if(len_p(*bpp) < RSPFLINKLEN) /* Packet too short */
  165.     return -1;
  166.     linkh->horizon = (unsigned char) pullchar(bpp);
  167.     linkh->erp = (unsigned char) pullchar(bpp);
  168.     linkh->cost = (unsigned char) pullchar(bpp);
  169.     linkh->adjn = (unsigned char) pullchar(bpp);
  170.     return 0;
  171. }
  172.